package main

import (
	"fmt"
	"go-learning/practice-function/anonymous"
	"go-learning/practice-function/closure"
	"go-learning/practice-function/recursive"
)

func main() {
	/*
		函数，为了完成某个封装起来的功能的集合
		做大括号要和 函数名 func 放在同一行
	*/
	var sum int
	var minus int
	sum, minus = addAndSubVar(1, 2)
	fmt.Println(sum, minus) // 3 -1

	var newSum int
	var newMinus int
	newSum, newMinus = addAndSubVar2(1, 1)
	fmt.Println(newSum, newMinus) // 2 0

	indeterminateParameters(4, 8, 3, 1, 6) //key and value: 0 4 1 8 2 3 3 1 4 6

	indeterminateParameters2(1, "demonlb", 3.152, true)
	/*
			1 int
		demonlb string
		3.152 float64
		unknown type
	*/

	var args int
	testScope(args) // 默认情况下不赋值，args 为0
	// 改变 testScope 里的 args 的值后 打印
	fmt.Println(args) // 依旧是 0 ，因为有作用域的原因

	// 递归函数
	recursive.Recursive()

	// 匿名函数
	anonymous.Anonymous()

	// 闭包函数
	func2 := closure.Closure()
	fmt.Println(func2(1)) // 1
	fmt.Println(func2(2)) // 3
	fmt.Println(func2(3)) // 6
}

// 函数的格式
/*
	func 函数名(参数)（返回值）{
		// 函数体
		return xxx
	}
*/

func addAndSubVar(var1 int, var2 int) (int, int) {
	// 上下两种方式一样
	// func addAndSubVar(var1 var2 int) (int, int) {
	return var1 + var2, var1 - var2
}

func addAndSubVar2(var1, var2 int) (sum int, minus int) {
	sum = var1 + var2
	minus = var1 - var2
	return sum, minus
	// 或者直接return就好，因为返回值写了返回哪些内容
}

// 函数的不定参数 使用 ... 来打印
func indeterminateParameters(args ...int) {
	for key, value := range args {
		fmt.Println(key, value)
	}
}

// 根据不同类型的参数分别打印

func indeterminateParameters2(args ...interface{}) {
	for _, value := range args {
		switch value.(type) {
		case int:
			fmt.Println(value, "int")
		case string:
			fmt.Println(value, "string")
		case float64:
			fmt.Println(value, "float64")
		default:
			fmt.Println("unknown type")
		}
	}
}

func testScope(args int) {
	// args = 100
	fmt.Println(args)
}
